home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / FPSE_src / mem.c < prev    next >
C/C++ Source or Header  |  2000-01-01  |  8KB  |  268 lines
  1. /*
  2.     Memory addressing
  3.     =================
  4.  
  5.     Written by BERO
  6.     Modified by LDChen
  7.     - Thanks to ROOR for the suggestions.
  8. */
  9.  
  10. #include "fpse.h"
  11.  
  12. // #define SHOW_READ
  13. // #define SHOW_WRITE
  14. // #define ENABLE_AR_EMULATION
  15.  
  16. #define MAXMEM  0x2000
  17.  
  18. void printpc(void);
  19.  
  20. static int writeok=1;
  21. static UINT8 *memPSXrd[MAXMEM];
  22. static UINT8 *memPSXwr[MAXMEM];
  23.  
  24. static void mem_ctrl(UINT32 data)
  25. {
  26.     int x;
  27.  
  28. /* ƒLƒƒƒbƒVƒ…ƒtƒ‰ƒbƒVƒ…—pH */
  29.     PRINTF("memctrl %08x\n",(int)data);
  30.     switch(data) {
  31.     case 0x00000800:
  32.     case 0x00000804:
  33. /* ƒLƒƒƒbƒVƒ…ƒƒ‚ƒŠ‚ð 0x0000000? */
  34.         writeok = 0;
  35.         break;
  36.     case 0x0001e988:
  37. /* ƒƒCƒ“ƒƒ‚ƒŠ */
  38.         writeok = 1;
  39.         break;
  40.     default:
  41.         printf("unknown memctrl %08x\n",(int)data);
  42.         break;
  43.     }
  44.     if (writeok) {
  45.         for (x=0; x<0x80; x++)
  46.             memPSXwr[x] = ram + (x & 0x1F) * 0x10000;
  47.     } else {
  48.         for (x=0; x<0x80; x++)
  49.             memPSXwr[x] = NULL;
  50.     }
  51. }
  52.  
  53. static char extrom_init[0x100] = {
  54.         0xb4,0x00,0x00,0x1f,0x4c,0x69,0x63,0x65,0x6e,0x73,0x65,0x64,0x20,0x62,0x79,0x20,
  55.         0x53,0x6f,0x6e,0x79,0x20,0x43,0x6f,0x6d,0x70,0x75,0x74,0x65,0x72,0x20,0x45,0x6e,
  56.         0x74,0x65,0x72,0x74,0x61,0x69,0x6e,0x6d,0x65,0x6e,0x74,0x20,0x49,0x6e,0x63,0x2e,
  57.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  58.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  59.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  60.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  61.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  62.         0xb4,0x00,0x00,0x1f,0x4c,0x69,0x63,0x65,0x6e,0x73,0x65,0x64,0x20,0x62,0x79,0x20,
  63.         0x53,0x6f,0x6e,0x79,0x20,0x43,0x6f,0x6d,0x70,0x75,0x74,0x65,0x72,0x20,0x45,0x6e,
  64.         0x74,0x65,0x72,0x74,0x61,0x69,0x6e,0x6d,0x65,0x6e,0x74,0x20,0x49,0x6e,0x63,0x2e,
  65.         0x00,0x00,0x00,0x00,0x08,0x00,0xe0,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  66.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  67.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  68.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  69.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  70. };
  71.  
  72. void memalloc(void)
  73. {
  74.     int x;
  75.  
  76. //                  ram      rom  extrom  scratchpad
  77.     ram = malloc(0x200000+0x80000+0x20000+0x10000);
  78.     memset(ram,0,0x200000+0x80000+0x20000+0x10000);
  79.  
  80.     rom        = ram    + 0x200000;
  81.     extrom     = rom    + 0x80000;
  82.     scratchpad = extrom + 0x20000;
  83.  
  84.     memset(extrom,0xff,0x20000);
  85.     memcpy(extrom,extrom_init,sizeof(extrom_init));
  86.  
  87.     for (x=0; x<MAXMEM; x++)
  88.     {
  89.         if (x>=0x0000 && x<0x0080)
  90.             memPSXwr[x] = memPSXrd[x] = ram + (x & 0x1F) * 0x10000;
  91.         else
  92.         if (x>=0x1fc0 && x<0x1fc8)
  93.         {
  94.             memPSXrd[x] = rom + (x & 0x07) * 0x10000;
  95.             memPSXwr[x] = NULL;
  96.         }
  97.         else
  98.         if (x>=0x1f00 && x<0x1f02)
  99.             memPSXwr[x] = memPSXrd[x] = extrom + (x & 0x01) * 0x10000;
  100.         else memPSXwr[x] = memPSXrd[x] = NULL;
  101.     }
  102.  
  103.     memPSXwr[0x1F80] = memPSXrd[0x1F80] = scratchpad;
  104. }
  105.  
  106. void memfree(void)
  107. {
  108.     free(ram);
  109. }
  110.  
  111. UINT8 read8(UINT32 adr)
  112. {
  113.     UINT8 *Pointer;
  114.  
  115.     Pointer = memPSXrd[(adr >> 16)&(MAXMEM-1)];
  116.     if (Pointer != NULL) {
  117. #ifdef SHOW_READ
  118.         PRINTF("%08x: READ8 [%08x]=%02x\n",PC,adr,Pointer[adr & 0xffff]);
  119. #endif
  120.         if (adr>=0x1f801000 && adr<0x1f808000) return hw_read8(adr);
  121.                                           else return Pointer[adr & 0xFFFF];
  122.     } else {
  123. #ifdef ENABLE_AR_EMULATION
  124.         if (adr>=0x1f000000 && adr<0x1f100000) return hw_romread(adr);
  125. #endif
  126.         printpc();
  127.         printf("can't read8 %08x at %08x\n",(int)adr,(int)PC);
  128.         return -1;
  129.     }
  130. }
  131.  
  132. UINT16 read16(UINT32 adr)
  133. {
  134.     UINT8 *Pointer;
  135.  
  136.     Pointer = memPSXrd[(adr >> 16)&(MAXMEM-1)];
  137.     if (Pointer != NULL) {
  138. #ifdef SHOW_READ
  139.         PRINTF("%08x: READ16 [%08x]=%04x\n",
  140.                PC,adr,*(UINT16 *)(Pointer + (adr & 0xFFFF));
  141. #endif
  142.         if (adr>=0x1f801000 && adr<0x1f808000) return hw_read16(adr);
  143.         else return SWAP16(*(UINT16 *)(Pointer + (adr & 0xFFFF)));
  144.     } else {
  145.         printpc();
  146.         printf("can't read16 %08x at %08x\n",(int)adr,(int)PC);
  147.         return -1;
  148.     }
  149. }
  150.  
  151. UINT32 read32(UINT32 adr)
  152. {
  153.     UINT8 *Pointer;
  154.  
  155.     Pointer = memPSXrd[(adr >> 16)&(MAXMEM-1)];
  156.     if (Pointer != NULL) {
  157. #ifdef SHOW_READ
  158.         PRINTF("%08x: READ32 [%08x]=%08x\n",
  159.                PC,adr,*(UINT32 *)(Pointer + (adr & 0xFFFF));
  160. #endif
  161.         if (adr>=0x1f801000 && adr<0x1f808000) return hw_read32(adr);
  162.         else return SWAP32(*(UINT32 *)(Pointer + (adr & 0xFFFF)));
  163.     } else {
  164.         printpc();
  165.         printf("can't read32 %08x at %08x\n",(int)adr,(int)PC);
  166.         return -1;
  167.     }
  168. }
  169.  
  170. void write8(UINT32 adr,UINT32 data)
  171. {
  172.     UINT8 *Pointer;
  173.  
  174.     Pointer = memPSXwr[(adr >> 16)&(MAXMEM-1)];
  175.     if (Pointer != NULL) {
  176. #ifdef SHOW_WRITE
  177.         PRINTF("%08x: WRITE8 [%08x]=%02x\n",PC,adr,data);
  178. #endif
  179.         Pointer[adr & 0xFFFF] = (UINT8)(data);
  180. //        CompileFlush(adr,adr);
  181.         if (adr>=0x1f801000 && adr<0x1f808000) hw_write8(adr,data);
  182.     } else {
  183. #ifdef ENABLE_AR_EMULATION
  184.         if (adr>=0x1f000000 && adr<0x1f100000) hw_romwrite(adr,data);
  185.         else
  186. #endif
  187.         {
  188.             printpc();
  189.             printf("can't write8 %08x at %08x\n",(int)adr,(int)PC);
  190.         }
  191.     }
  192. }
  193.  
  194. void write16(UINT32 adr,UINT32 data)
  195. {
  196.     UINT8 *Pointer;
  197.  
  198.     Pointer = memPSXwr[(adr >> 16)&(MAXMEM-1)];
  199.     if (Pointer != NULL) {
  200. #ifdef SHOW_WRITE
  201.         PRINTF("%08x: WRITE16 [%08x]=%04x\n",PC,adr,data);
  202. #endif
  203. //        CompileFlush(adr,adr);
  204.         *(UINT16 *)(Pointer + (adr & 0xFFFF)) = SWAP16((UINT16)(data));
  205.         if (adr>=0x1f801000 && adr<0x1f808000) hw_write16(adr,data);
  206.     } else {
  207.         printpc();
  208.         printf("can't write16 %08x at %08x\n",(int)adr,(int)PC);
  209.     }
  210. }
  211.  
  212. extern int writebreak;
  213.  
  214. void write32(UINT32 adr,UINT32 data)
  215. {
  216.     UINT8 *Pointer;
  217.  
  218.     Pointer = memPSXwr[(adr >> 16)&(MAXMEM-1)];
  219.     if (Pointer != NULL) {
  220. #ifdef SHOW_WRITE
  221.         PRINTF("%08x: WRITE32 [%08x]=%08x\n",PC,adr,data);
  222. #endif
  223. //        CompileFlush(adr,adr);
  224.         *(UINT32 *)(Pointer + (adr & 0xFFFF)) = SWAP32(data);
  225.         if (adr>=0x1f801000 && adr<0x1f808000) hw_write32(adr,data);
  226.     } else {
  227.         if (adr==0xfffe0130) mem_ctrl(data);
  228.         else if (writeok) {
  229.             printpc();
  230.             printf("can't write32 %08x at %08x\n",(int)adr,(int)PC);
  231.         }
  232.     }
  233. }
  234.  
  235. void *baseaddr(UINT32 adr)
  236. {
  237.     if ((adr>=0x80000000 && adr<0x80800000) ||
  238.         (adr>=0xa0000000 && adr<0xa0800000) ||
  239.         (adr>=0x00000000 && adr<0x00800000)) return ram - (adr&~0x1fffff);
  240.  
  241.     if ((adr>=0xbfc00000 && adr<0xbfc80000) ||
  242.         (adr>=0x1fc00000 && adr<0x1fc80000) ||
  243.         (adr>=0x9fc00000 && adr<0x9fc80000)) return rom - (adr & ~0x7FFFF);
  244.  
  245.     else if (adr>=0x1f800000 && adr<0x1f801000) return scratchpad - 0x1f800000;
  246.     else if (adr>=0x1f000000 && adr<0x1f020000) return extrom - 0x1f000000;
  247.     else { FPSE_Flags |= STOP;
  248.                printpc();
  249.                printf("can't exec %08x\n",(int)adr);
  250.     }
  251.     return NULL;
  252. }
  253.  
  254. #if 0
  255. void *baseaddr2(UINT32 adr)
  256. {
  257.     if ((adr>=0x80000000 && adr<0x80800000) ||
  258.         (adr>=0xa0000000 && adr<0xa0800000) ||
  259.         (adr>=0x00000000 && adr<0x00800000)) return ram - (adr&~0x1fffff);
  260.  
  261.     if ((adr>=0xbfc00000 && adr<0xbfc80000) ||
  262.         (adr>=0x1fc00000 && adr<0x1fc80000) ||
  263.         (adr>=0x9fc00000 && adr<0x9fc80000)) return rom - (adr & ~0x7FFFF);
  264.  
  265.     else if (adr>=0x1f800000 && adr<0x1f801000) return scratchpad - 0x1f800000;
  266.     return NULL;
  267. }
  268. #endif